6.046J Lecture 10: Hashing and amortization

10.1 Arrays and Hashing Arrays are very useful. The items in an array are statically addressed, so that inserting, deleting, and looking up an element each take O(1) time. Thus, arrays are a terrific way to encode functions { 1, . . . ,n }→ T, where T is some range of values and n is known ahead of time. For example, taking T = {0,1}, we find that an array A of n bits is a great way to store a subset of {1, . . . ,n}: we set A[i] = 1 if and only if i is in the set (see Figure 10.1). Or, interpreting the bits as binary digits, we can use an n-bit array to store an integer between 0 and 2n−1. In this way, we will often identify the set {0,1}n with the set {0, . . . ,2n −1}. What if we wanted to encode subsets of an arbitrary domain U , rather than just {1, . . . ,n}? Or to put things differently, what if we wanted a keyed (or associative) array, where the keys could be arbitrary strings? While the workings of such data structures (such as dictionaries in Python) are abstracted away in many programming languages, there is usually an array-based solution working behind the scenes. Implementing associative arrays amounts to finding a way to turn a key into an array index. Thus, we are looking for a suitable function U → {1, . . . ,n}, called a hash function. Equipped with this function, we can perform key lookup: U hash function −−−−−−−−−→ {1, . . . ,n} array lookup −−−−−−−−−→ T (see Figure 10.2). This particular implementation of associative arrays is called a hash table. There is a problem, however. Typically, the domain U is much larger than {1, . . . ,n}. For any hash function h : U → {1, . . . ,n}, there is some i such that at least |U | n elements are mapped to i. The set